diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index c8c74f1..f80e7b9 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -57,51 +57,60 @@
 
 <h1>Change Log</h1>
 
-
 <h2>Version 1.6.2</h2>
 <p>Release Date: not currently released</p>
 <ul>
-    <li>No additions currently listed</li>
-    <li>Added 'application/vnd.ms-powerpoint' to list of mime types.<br />
+    <li>Config
+    	<ul>
+    		<li>Added 'application/vnd.ms-powerpoint' to list of mime types.</li>
+    	</ul>
+    </li>
+    <li>Helpers
+    	<ul>
+    		<li>Modified <kbd>img()</kbd> in the <a href="helpers/html_helper.html">HTML Helper</a> to remove an unneeded space.</li>
+    		<li>Modified <kbd>anchor()</kbd> in the <a href="helpers/url_helper.html">URL helper</a> to convert entities in the title attribute.</li>
+    	</ul>
     </li>
 </ul>
+
 <h3>Bugfixes for 1.6.2</h3>
 <ul>
-    <li>Fixed assorted user guide typos (#3453)</li>
-	<li>Fixed an AR_caching error where it wasn't tracking table aliases (#3463)</li>
-	<li>Fixed a bug in the DB class testing the $params argument</li>
+    <li>Fixed assorted user guide typos (#3453).</li>
+	<li>Fixed an AR_caching error where it wasn't tracking table aliases (#3463).</li>
+	<li>Fixed a bug in the DB class testing the $params argument.</li>
 	<li>Fixed a bug in the Table library where the integer 0 in cell data would be displayed as a blank cell.</li>
 	<li>Fixed a bug (#3523) in get_filenames() with recursion.</p>
 </ul>
+
 <h2>Version 1.6.1</h2>
 <p>Release Date: February 12, 2008</p>
-
 <ul>
 	<li>Active Record 
 		<ul>
 			<li>Added <a href="./database/active_record.html#caching">Active Record Caching</a>.</li>
-			<li>Made Active Record fully database-prefix aware</li>
+			<li>Made Active Record fully database-prefix aware.</li>
 		</ul>
 	</li>
 	<li>Database drivers
 		<ul>
-			<li>Added support for setting client character set and collation for MySQLi</li>
+			<li>Added support for setting client character set and collation for MySQLi.</li>
 		</ul>
 	</li>
 	<li>Core Changes
 		<ul>
-			<li>Modified xss_clean() to be more intelligent with its handling of URL encoded strings.</li>
+			<li>Modified <kbd>xss_clean()</kbd> to be more intelligent with its handling of URL encoded strings.</li>
 			<li>Added $_SERVER, $_FILES, $_ENV, and $_SESSION to sanitization of globals.</li>
 		    <li>Added a <a href="./helpers/path_helper.html">Path Helper</a>.</li>
-			<li>Simplified _reindex_segments() in the URI class</li>
+			<li>Simplified <kbd>_reindex_segments()</kbd> in the URI class.</li>
 			<li>Escaped the '-' in the default 'permitted_uri_chars' config item, to prevent errors if developers just try to add additional characters to the end of the default expression.</li>
-			<li>Modified method calling to controllers to show a 404 when a private or protected method is accessed via a URL</li>
-			<li>Modified framework initiated 404s to log the controller and method for invalid requests</li>
+			<li>Modified method calling to controllers to show a 404 when a private or protected method is accessed via a URL.</li>
+			<li>Modified framework initiated 404s to log the controller and method for invalid requests.</li>
 		</ul>
 	</li>
 	<li>Helpers
 		<ul>
-			<li>Modified get_filenames() in the File Helper to return FALSE if the $source_dir is not readable</li>
+			<li>Modified <kbd>get_filenames()</kbd> in the File Helper to return FALSE if the $source_dir is not readable.</li>
+			</ul>
 	</li>
 </ul>
 
@@ -110,12 +119,12 @@
 <ul>
 	<li>Deprecated is_numeric as a validation rule. Use of numeric and integer are preferred.</li>
 	<li>Fixed bug (#3379) in DBForge with SQLite for table creation.</li>
-	<li>Made Active Record fully database prefix aware (#3384)</li>
-	<li>Fixed a bug where DBForge was outputting invalid SQL in Postgres by adding brackets around the tables in FROM</li>
+	<li>Made Active Record fully database prefix aware (#3384).</li>
+	<li>Fixed a bug where DBForge was outputting invalid SQL in Postgres by adding brackets around the tables in FROM.</li>
 	<li>Changed the behaviour of Active Record's update() to make the WHERE clause optional (#3395).</li>
     <li>Fixed a bug (#3396) where certain POST variables would cause a PHP warning.</li>
     <li>Fixed a bug in query binding (#3402).</li>
-	<li>Changed order of SQL keywords in the Profiler $highlight array so OR would not be highlighted before ORDER BY</li>
+	<li>Changed order of SQL keywords in the Profiler $highlight array so OR would not be highlighted before ORDER BY.</li>
 	<li>Fixed a bug (#3404) where the MySQLi driver was testing if $this->conn_id was a resource instead of an object.</li>
 	<li>Fixed a bug (#3419) connecting to a database via a DSN string.</li>
 	<li>Fixed a bug (#3445) where the routed segment array was not re-indexed to begin with 1 when the default controller is used.</li>
